package 炫彩窗口基类

import (
	objectbase "gitee.com/go_888/xcgui/xcgui/objectbase"
	wnd "gitee.com/go_888/xcgui/xcgui/wapi/wnd"
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// windowBase 窗口基类.
type windowBase struct {
	objectbase.X结构_可视对象
}

// 模态窗口_启用自动关闭, 是否自动关闭窗口, 当窗口失去焦点时.
//
// bEnable: 开启开关.
func (m *windowBase) X启用自动关闭(开启开关 bool) *windowBase {
	xc.X模态窗口_启用自动关闭(m.X句柄, 开启开关)
	return m
}

// 模态窗口_启用ESC关闭, 当用户按ESC键时自动关闭模态窗口.
//
// bEnable: 是否启用.
func (m *windowBase) X启用ESC关闭(是否启用 bool) *windowBase {
	xc.X模态窗口_启用ESC关闭(m.X句柄, 是否启用)
	return m
}

// 模态窗口_启动, 启动显示模态窗口, 当窗口关闭时返回:
//   - xcc.MessageBox_Flag_Ok: 点击确定按钮退出.
//   - xcc.MessageBox_Flag_Cancel: 点击取消按钮退出.
//   - xcc.MessageBox_Flag_Other: 其他方式退出.
func (m *windowBase) X启动() xcc.X消息框 {
	return xc.X模态窗口_启动(m.X句柄)
}

// 模态窗口_结束, 结束模态窗口.
//
// nResult: 用作 xc.XModalWnd_DoModal 的返回值:
//   - xcc.MessageBox_Flag_Ok: 点击确定按钮退出.
//   - xcc.MessageBox_Flag_Cancel: 点击取消按钮退出.
//   - xcc.MessageBox_Flag_Other: 其他方式退出.
func (m *windowBase) X结束(结果 xcc.X消息框) *windowBase {
	xc.X模态窗口_结束(m.X句柄, 结果)
	return m
}

// MessageBox 炫彩_消息框. 返回值如下:
//   - xcc.MessageBox_Flag_Ok: 点击确定按钮退出.
//   - xcc.MessageBox_Flag_Cancel: 点击取消按钮退出.
//   - xcc.MessageBox_Flag_Other: 其他方式退出.
//
// pTitle: 标题.
//
// pText: 内容文本.
//
// nFlags: 标识: xcc.MessageBox_Flag_.
//
// XCStyle: xcc.Window_Style_.
func (w *windowBase) X消息框(标题, 内容 string, 标识 xcc.X消息框, XC样式 xcc.X窗口样式) xcc.X消息框 {
	return xc.X消息框(标题, 内容, 标识, w.X取HWND句柄(), XC样式)
}

// Msg_Create 消息框_创建, 返回消息框窗口对象.
//
// pTitle: 标题.
//
// pText: 内容文本.
//
// nFlags: 标识: xcc.MessageBox_Flag_.
//
// XCStyle: xcc.Window_Style_.
func (w *windowBase) X消息框创建(标题, 内容 string, 标识 xcc.X消息框, XC样式 xcc.X窗口样式) *Window {
	wd := &Window{}
	hWindow := xc.X消息框_创建(标题, 内容, 标识, w.X取HWND句柄(), XC样式)
	if xc.X判断窗口(hWindow) {
		wd.X设置句柄(hWindow)
	}
	return wd
}

// Msg_CreateEx 消息框_创建扩展, 返回消息框窗口对象.
//
// dwExStyle: 窗口扩展样式, xcc.WS_EX_ 常量组合.
//
// dwStyle: 窗口样式, xcc.WS_ 常量组合.
//
// lpClassName: 窗口类名.
//
// pTitle: 标题.
//
// pText: 内容文本.
//
// nFlags: 标识: xcc.MessageBox_Flag_.
//
// XCStyle: xcc.Window_Style_.
func (w *windowBase) X消息框创建EX(dwExStyle xcc.WS_EX_, 窗口样式 xcc.WS_, 窗口类名, 标题, 内容 string, 标识 xcc.X消息框, XC样式 xcc.X窗口样式) *Window {
	wd := &Window{}
	hWindow := xc.X消息框_创建EX(dwExStyle, 窗口样式, 窗口类名, 标题, 内容, 标识, w.X取HWND句柄(), XC样式)
	if xc.X判断窗口(hWindow) {
		wd.X设置句柄(hWindow)
	}
	return wd
}

// 炫彩_发送窗口消息.
//
// msg:.
//
// wParam:.
//
// lParam:.
func (w *windowBase) X发送窗口消息(消息值 uint32, 参数1, 参数2 uintptr) uintptr {
	return xc.X发送窗口消息(w.X句柄, 消息值, 参数1, 参数2)
}

// 炫彩_投递窗口消息.
//
// msg:.
//
// wParam:.
//
// lParam:.
func (w *windowBase) X投递窗口消息(消息值 uint32, 参数1, 参数2 uintptr) bool {
	return xc.X投递窗口消息(w.X句柄, 消息值, 参数1, 参数2)
}

// 炫彩_判断窗口, 判断是否为窗口句柄.
func (w *windowBase) X判断窗口() bool {
	return xc.X判断窗口(w.X句柄)
}

// 炫彩_取对象从ID, 通过ID获取对象句柄, 不包括窗口对象.
//
// nID: ID值.
func (w *windowBase) X取对象并按ID(ID值 int32) int {
	return xc.X取对象并按ID(w.X句柄, ID值)
}

// 炫彩_取对象从ID名称, 通过ID名称获取对象句柄.
//
// pName: ID名称.
func (w *windowBase) X取对象并按ID名称(ID名称 string) int {
	return xc.X取对象并按ID名称(w.X句柄, ID名称)
}

// 窗口_显示.
//
// nCmdShow: 显示方式: xcc.SW_.
func (w *windowBase) X显示方式(显示方式 xcc.X窗口显示方式) bool {
	return xc.X窗口_显示方式(w.X句柄, 显示方式)
}

// 窗口_置顶.
//
// bTop: 是否置顶.
func (w *windowBase) X设置顶(bTop ...bool) *windowBase {
	xc.X窗口_设置顶(w.X句柄, bTop...)
	return w
}

// 窗口_移除事件. 只适用于 AddEvent_ 方式添加的事件.
//
// nEvent: 事件类型: xcc.WM_, xcc.XWM_.
//
// index: 使用 AddEvent_ 函数返回的回调函数索引.
//   - 为空时, 直接移除事件.
//   - 不为空时, 移除指定索引的回调函数.
func (w *windowBase) RemoveEvent(nEvent xcc.X窗口事件, index ...int) *windowBase {
	if len(index) > 0 {
		EventHandler.RemoveCallBack(w.X句柄, nEvent, index[0])
	} else { // 移除事件
		cbPtr := EventHandler.EventInfoMap[w.X句柄][nEvent].EvnetFuncPtr
		if cbPtr > 0 {
			xc.X窗口_移除事件CEx(w.X句柄, nEvent, cbPtr)
		}
		EventHandler.RemoveEvent(w.X句柄, nEvent)
	}
	return w
}

// 窗口_注册事件C.
//
// nEvent: 事件类型: xcc.WM_, xcc.XWM_.
//
// fun: 事件函数.
func (w *windowBase) X注册事件C(事件类型 xcc.X窗口事件, fun interface{}) bool {
	return xc.X窗口_注册事件C(w.X句柄, 事件类型, fun)
}

// 窗口_注册事件C1.
//
// nEvent: 事件类型: xcc.WM_, xcc.XWM_.
//
// fun: 事件函数.
func (w *windowBase) X注册事件C1(事件类型 xcc.X窗口事件, fun interface{}) bool {
	return xc.X窗口_注册事件C1(w.X句柄, 事件类型, fun)
}

// 窗口_移除事件C.
//
// nEvent: 事件类型: xcc.WM_, xcc.XWM_.
//
// fun: 事件函数.
func (w *windowBase) X移除事件C(事件类型 xcc.X窗口事件, fun interface{}) bool {
	return xc.X窗口_移除事件C(w.X句柄, 事件类型, fun)
}

// 窗口_移除事件CEx, 和非Ex版相比只是最后一个参数不同.
//
// nEvent: 事件类型: xcc.WM_, xcc.XWM_.
//
// pFun: 事件函数指针, 使用 syscall.NewCallback() 生成..
func (w *windowBase) X移除事件CEx(事件类型 xcc.X窗口事件, 回调函数 uintptr) bool {
	return xc.X窗口_移除事件CEx(w.X句柄, 事件类型, 回调函数)
}

// 窗口_添加子对象.
//
// hChild: 要添加的对象句柄.
func (w *windowBase) X添加子对象(对象句柄 int) bool {
	return xc.X窗口_添加子对象(w.X句柄, 对象句柄)
}

// 窗口_插入子对象.
//
// hChild: 要插入的对象句柄.
//
// index: 插入位置索引.
func (w *windowBase) X插入子对象(子对象句柄 int, 位置索引 int32) bool {
	return xc.X窗口_插入子对象(w.X句柄, 子对象句柄, 位置索引)
}

// 窗口_取HWND.
func (w *windowBase) X取HWND句柄() uintptr {
	return xc.X窗口_取HWND句柄(w.X句柄)
}

// 窗口_重绘.
//
// bImmediate: 是否立即重绘, 通常为false即可.
func (w *windowBase) X重绘(立即重绘 ...bool) *windowBase {
	b := false
	if len(立即重绘) > 0 {
		b = 立即重绘[0]
	}
	xc.X窗口_重绘(w.X句柄, b)
	return w
}

// 窗口_重绘指定区域.
//
// pRect: 需要重绘的区域坐标.
//
// bImmediate: TRUE立即重绘, FALSE放入消息队列延迟重绘.
func (w *windowBase) X重绘指定区域(矩形区域 *xc.X结构_矩形, 立即重绘 bool) *windowBase {
	xc.X窗口_重绘指定区域(w.X句柄, 矩形区域, 立即重绘)
	return w
}

// 窗口_置坐标.
//
// pRect: 坐标.
func (w *windowBase) X设置坐标(矩形 *xc.X结构_矩形) *windowBase {
	xc.X窗口_设置坐标(w.X句柄, 矩形)
	return w
}

// 窗口_置焦点.
//
// hFocusEle: 将获得焦点的元素.
func (w *windowBase) X设置焦点(元素 int) *windowBase {
	xc.X窗口_设置焦点(w.X句柄, 元素)
	return w
}

// 窗口_取焦点.
func (w *windowBase) X取焦点() int {
	return xc.X窗口_取焦点(w.X句柄)
}

// 窗口_取鼠标停留元素.
func (w *windowBase) X取鼠标停留元素() int {
	return xc.X窗口_取鼠标停留元素(w.X句柄)
}

// 窗口_绘制, 在自绘事件函数中,用户手动调用绘制窗口, 以便控制绘制顺序.
//
// hDraw: 图形绘制句柄.
func (w *windowBase) X绘制(图形绘制句柄 int) *windowBase {
	xc.X窗口_绘制(w.X句柄, 图形绘制句柄)
	return w
}

// 窗口_居中.
func (w *windowBase) X设置居中() *windowBase {
	xc.X窗口_设置居中(w.X句柄)
	return w
}

// 窗口_居中扩展.
//
// width: 窗口宽度.
//
// height: 窗口高度.
func (w *windowBase) X设置居中EX(宽度, 高度 int32) *windowBase {
	xc.X窗口_设置居中EX(w.X句柄, 宽度, 高度)
	return w
}

// 窗口_置光标.
//
// hCursor: 鼠标光标句柄.
func (w *windowBase) X设置光标(鼠标光标句柄 uintptr) *windowBase {
	xc.X窗口_设置光标(w.X句柄, 鼠标光标句柄)
	return w
}

// 窗口_取光标.
func (w *windowBase) X取光标() uintptr {
	return xc.X窗口_取光标(w.X句柄)
}

// 窗口_启用拖动边框.
//
// bEnable: 是否启用.
func (w *windowBase) X启用拖动边框(是否启用 bool) *windowBase {
	xc.X窗口_启用拖动边框(w.X句柄, 是否启用)
	return w
}

// 窗口_启用拖动窗口.
//
// bEnable: 是否启用.
func (w *windowBase) X启用拖动窗口(是否启用 bool) *windowBase {
	xc.X窗口_启用拖动窗口(w.X句柄, 是否启用)
	return w
}

// 窗口_启用拖动标题栏.
//
// bEnable: 是否启用.
func (w *windowBase) X启用拖动标题栏(是否启用 bool) *windowBase {
	xc.X窗口_启用拖动标题栏(w.X句柄, 是否启用)
	return w
}

// 窗口_启用绘制背景.
//
// bEnable: 是否启用.
func (w *windowBase) X启用绘制背景(是否启用 bool) *windowBase {
	xc.X窗口_启用绘制背景(w.X句柄, 是否启用)
	return w
}

// 窗口_启用自动焦点. 当鼠标左键按下是否获得焦点.
//
// bEnable: 是否启用.
func (w *windowBase) X启用自动焦点(是否启用 bool) *windowBase {
	xc.X窗口_启用自动焦点(w.X句柄, 是否启用)
	return w
}

// 窗口_启用允许最大化.
//
// bEnable: 是否启用.
func (w *windowBase) X启用允许最大化(是否启用 bool) *windowBase {
	xc.X窗口_启用允许最大化(w.X句柄, 是否启用)
	return w
}

// 窗口_启用限制窗口大小.
//
// bEnable: 是否启用.
func (w *windowBase) X启用限制窗口大小(是否启用 bool) *windowBase {
	xc.X窗口_启用限制窗口大小(w.X句柄, 是否启用)
	return w
}

// 窗口_启用布局.
//
// bEnable: 是否启用.
func (w *windowBase) X启用布局(是否启用 bool) *windowBase {
	xc.X窗口_启用布局(w.X句柄, 是否启用)
	return w
}

// 窗口_启用布局覆盖边框.
//
// bEnable: 是否启用.
func (w *windowBase) X启用布局覆盖边框(是否启用 bool) *windowBase {
	xc.X窗口_启用布局覆盖边框(w.X句柄, 是否启用)
	return w
}

// 窗口_显示布局边界.
//
// bEnable: 是否启用.
func (w *windowBase) X显示布局边界(是否启用 bool) *windowBase {
	xc.X窗口_显示布局边界(w.X句柄, 是否启用)
	return w
}

// 窗口_判断启用布局.
func (w *windowBase) X判断启用布局() bool {
	return xc.X窗口_判断启用布局(w.X句柄)
}

// 窗口_是否最大化.
func (w *windowBase) X是否最大化() bool {
	return xc.X窗口_是否最大化(w.X句柄)
}

// 窗口_置鼠标捕获元素.
//
// hEle: 元素句柄.
func (w *windowBase) X设置鼠标捕获元素(元素句柄 int) *windowBase {
	xc.X窗口_设置鼠标捕获元素(w.X句柄, 元素句柄)
	return w
}

// 窗口_取鼠标捕获元素.
func (w *windowBase) X取鼠标捕获元素() int {
	return xc.X窗口_取鼠标捕获元素(w.X句柄)
}

// 窗口_取绘制矩形.
//
// pRcPaint: 重绘区域坐标.
func (w *windowBase) X取重绘区域(返回坐标 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取重绘区域(w.X句柄, 返回坐标)
	return w
}

// 窗口_取绘制矩形ex.
func (w *windowBase) X取重绘矩形EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取重绘区域(w.X句柄, &rc)
	return rc
}

// 窗口_置系统光标.
//
// hCursor: 光标句柄.
func (w *windowBase) X设置系统光标(光标句柄 uintptr) uintptr {
	return xc.X窗口_设置系统光标(w.X句柄, 光标句柄)
}

// 窗口_置字体.
//
// hFontx: 炫彩字体句柄.
func (w *windowBase) X设置字体(炫彩字体句柄 int) *windowBase {
	xc.X窗口_设置字体(w.X句柄, 炫彩字体句柄)
	return w
}

// 窗口_置文本颜色.
//
// color: xc.RGBA 颜色值.
func (w *windowBase) X设置文本颜色(ABGR颜色值 int) *windowBase {
	xc.X窗口_设置文本颜色(w.X句柄, ABGR颜色值)
	return w
}

// 窗口_取文本颜色, 返回xc.RGBA 颜色.
func (w *windowBase) X取文本颜色() int {
	return xc.X窗口_取文本颜色(w.X句柄)
}

// 窗口_取文本颜色扩展, 返回xc.RGBA 颜色.
func (w *windowBase) X取文本颜色EX() int {
	return xc.X窗口_取文本颜色EX(w.X句柄)
}

// 窗口_置ID.
//
// nID: ID值.
func (w *windowBase) X设置ID(ID值 int32) *windowBase {
	xc.X窗口_设置ID(w.X句柄, ID值)
	return w
}

// 窗口_取ID.
func (w *windowBase) X取ID() int32 {
	return xc.X窗口_取ID(w.X句柄)
}

// 窗口_置名称.
//
// pName: name值, 字符串.
func (w *windowBase) X设置名称(名称 string) *windowBase {
	xc.X窗口_设置名称(w.X句柄, 名称)
	return w
}

// 窗口_取名称.
func (w *windowBase) X取名称() string {
	return xc.X窗口_取名称(w.X句柄)
}

// 窗口_置边大小.
//
// left: 窗口左边大小.
//
// top: 窗口上边大小.
//
// right: 窗口右边大小.
//
// bottom: 窗口底部大小.
func (w *windowBase) X设置边大小(左边, 上边, 右边, 底部 int32) *windowBase {
	xc.X窗口_设置边大小(w.X句柄, 左边, 上边, 右边, 底部)
	return w
}

// 窗口_取边大小.
//
// pBorder: 返回边大小.
func (w *windowBase) X取边大小(返回大小 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取边大小(w.X句柄, 返回大小)
	return w
}

// 窗口_取边大小ex.
func (w *windowBase) X取边大小EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取边大小(w.X句柄, &rc)
	return rc
}

// 窗口_置布局内填充大小.
//
// left: 左边大小.
//
// top: 上边大小.
//
// right: 右边大小.
//
// bottom: 下边大小.
func (w *windowBase) X设置布局内填充大小(左边, 上边, 右边, 下边 int32) *windowBase {
	xc.X窗口_设置布局内填充大小(w.X句柄, 左边, 上边, 右边, 下边)
	return w
}

// 窗口_取布局内填充大小.
//
// pPadding: 返回布局内填充大小.
func (w *windowBase) X取布局内填充大小(返回大小 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取布局内填充大小(w.X句柄, 返回大小)
	return w
}

// 窗口_取布局内填充大小ex.
func (w *windowBase) X取布局内填充大小EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取布局内填充大小(w.X句柄, &rc)
	return rc
}

// 窗口_置拖动边框大小.
//
// left: 窗口左边大小.
//
// top: 窗口上边大小.
//
// right: 窗口右边大小.
//
// bottom: 窗口底边大小.
func (w *windowBase) X设置拖动边框大小(左边, 上边, 右边, 底边 int32) *windowBase {
	xc.X窗口_设置拖动边框大小(w.X句柄, 左边, 上边, 右边, 底边)
	return w
}

// 窗口_取拖动边框大小.
//
// pSize: 拖动边框大小.
func (w *windowBase) X取拖动边框大小(返回大小 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取拖动边框大小(w.X句柄, 返回大小)
	return w
}

// 窗口_取拖动边框大小ex.
func (w *windowBase) X取拖动边框大小EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取拖动边框大小(w.X句柄, &rc)
	return rc
}

// 窗口_置最小大小.
//
// width: 最小宽度.
//
// height: 最小高度.
func (w *windowBase) X设置最小大小(最小宽度, 最小高度 int32) *windowBase {
	xc.X窗口_设置最小大小(w.X句柄, 最小宽度, 最小高度)
	return w
}

// 窗口_测试点击子元素. 成功则返回元素句柄.
//
// pPt: 左边点.
func (w *windowBase) X测试点击子元素(左边点 *xc.X结构_坐标) int {
	return xc.X窗口_测试点击子元素(w.X句柄, 左边点)
}

// 窗口_取子对象数量.
func (w *windowBase) X取子对象数量() int32 {
	return xc.X窗口_取子对象数量(w.X句柄)
}

// 窗口_取子对象从索引.
//
// index: 元素索引.
func (w *windowBase) X取子对象并按索引(元素索引 int32) int {
	return xc.X窗口_取子对象从索引(w.X句柄, 元素索引)
}

// 窗口_取子对象从ID.
//
// nID: 元素ID, ID必须大于0.
func (w *windowBase) X取子对象并按ID(元素ID int32) int {
	return xc.X窗口_取子对象从ID(w.X句柄, 元素ID)
}

// 窗口_取子对象.
//
// nID: 对象ID,ID必须大于0.
func (w *windowBase) X取子对象(对象ID int32) int {
	return xc.X窗口_取子对象(w.X句柄, 对象ID)
}

// 窗口_关闭.
func (w *windowBase) X关闭() *windowBase {
	xc.X窗口_关闭(w.X句柄)
	return w
}

// 窗口_调整布局.
func (w *windowBase) X调整布局() *windowBase {
	xc.X窗口_调整布局(w.X句柄)
	return w
}

// 窗口_调整布局扩展.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
func (w *windowBase) X调整布局EX(调整布局标识位 xcc.X调整布局标识位) *windowBase {
	xc.X窗口_调整布局EX(w.X句柄, 调整布局标识位)
	return w
}

// 窗口_创建插入符.
//
// hEle: 元素句柄.
//
// x: x坐标.
//
// y: y坐标.
//
// width: 宽度.
//
// height: 高度.
func (w *windowBase) X创建插入符(元素句柄 int, x坐标, y坐标, 宽度, 高度 int32) *windowBase {
	xc.X窗口_创建插入符(w.X句柄, 元素句柄, x坐标, y坐标, 宽度, 高度)
	return w
}

// 窗口_置插入符位置, 设置插入符位置.
//
// x: x坐标.
//
// y: y坐标.
//
// width: 宽度.
//
// height: 高度.
//
// bUpdate: 是否立即更新UI.
func (w *windowBase) X设置插入符位置(x坐标, y坐标, 宽度, 高度 int32, 立即更新UI bool) *windowBase {
	xc.X窗口_设置插入符位置(w.X句柄, x坐标, y坐标, 宽度, 高度, 立即更新UI)
	return w
}

// 窗口_置插入符颜色.
//
// color: 颜色值, xc.RGBA 颜色.
func (w *windowBase) X设置插入符颜色(颜色值 int) *windowBase {
	xc.X窗口_设置插入符颜色(w.X句柄, 颜色值)
	return w
}

// 窗口_显示插入符.
//
// bShow: 是否显示.
func (w *windowBase) X显示插入符(是否显示 bool) *windowBase {
	xc.X窗口_显示插入符(w.X句柄, 是否显示)
	return w
}

// 窗口_销毁插入符.
func (w *windowBase) X销毁插入符() *windowBase {
	xc.X窗口_销毁插入符(w.X句柄)
	return w
}

// 窗口_取插入符元素.
func (w *windowBase) X取插入符元素() int {
	return xc.X窗口_取插入符元素(w.X句柄)
}

// 窗口_取客户区坐标.
//
// pRect: 坐标.
func (w *windowBase) X取客户区坐标(返回矩形 *xc.X结构_矩形) bool {
	return xc.X窗口_取客户区坐标(w.X句柄, 返回矩形)
}

// 窗口_取客户区坐标ex.
func (w *windowBase) X取客户区坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取客户区坐标(w.X句柄, &rc)
	return rc
}

// 窗口_取Body坐标.
//
// pRect: 坐标.
func (w *windowBase) X取Body坐标(返回矩形 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取Body坐标(w.X句柄, 返回矩形)
	return w
}

// 窗口_取Body坐标ex.
func (w *windowBase) X取Body坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取Body坐标(w.X句柄, &rc)
	return rc
}

// 窗口_取布局坐标.
//
// pRect: 接收返回坐标.
func (w *windowBase) X取布局坐标(返回矩形 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取布局坐标(w.X句柄, 返回矩形)
	return w
}

// 窗口_取布局坐标ex.
func (w *windowBase) X取布局坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取布局坐标(w.X句柄, &rc)
	return rc
}

// 窗口_移动窗口.
//
// x: X坐标.
//
// y: Y坐标.
func (w *windowBase) X移动窗口(坐标, Y坐标 int32) *windowBase {
	xc.X窗口_移动窗口(w.X句柄, 坐标, Y坐标)
	return w
}

// 窗口_取坐标.
//
// pRect: 坐标.
func (w *windowBase) X取坐标(矩形 *xc.X结构_矩形) *windowBase {
	xc.X窗口_取坐标(w.X句柄, 矩形)
	return w
}

// 窗口_取坐标ex.
func (w *windowBase) X取坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc
}

// 窗口_取坐标ex. 返回的坐标已经根据窗口dpi进行换算了, 换算后的结果就是屏幕上显示的真实坐标了.
func (w *windowBase) GetRectDPI() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X窗口_取坐标(w.X句柄, &rc)
	dpi := xc.X窗口_取DPI(w.X句柄)
	rc.X左 = xc.DpiConv(dpi, rc.X左)
	rc.X上 = xc.DpiConv(dpi, rc.X上)
	rc.X右 = xc.DpiConv(dpi, rc.X右)
	rc.X下 = xc.DpiConv(dpi, rc.X下)
	return rc
}

// 窗口_最大化.
//
// bMaximize: 是否最大化.
func (w *windowBase) X最大化(是否最大化 bool) *windowBase {
	xc.X窗口_最大化(w.X句柄, 是否最大化)
	return w
}

// 窗口_置定时器.
//
// nIDEvent: 定时器ID.
//
// uElapse: 间隔值, 单位毫秒.
func (w *windowBase) X设置定时器(定时器ID, 间隔值 uint32) uint32 {
	return xc.X窗口_设置定时器(w.X句柄, 定时器ID, 间隔值)
}

// 窗口_关闭定时器.
//
// nIDEvent: 定时器ID.
func (w *windowBase) X关闭定时器(定时器ID uint32) bool {
	return xc.X窗口_关闭定时器(w.X句柄, 定时器ID)
}

// 窗口_置炫彩定时器.
//
// nIDEvent: 定时器ID.
//
// uElapse: 间隔值, 单位毫秒.
func (w *windowBase) X设置炫彩定时器(定时器ID, 间隔值 uint32) bool {
	return xc.X窗口_设置炫彩定时器(w.X句柄, 定时器ID, 间隔值)
}

// 窗口_关闭炫彩定时器.
//
// nIDEvent: 定时器ID.
func (w *windowBase) X关闭炫彩定时器(定时器ID uint32) bool {
	return xc.X窗口_关闭炫彩定时器(w.X句柄, 定时器ID)
}

// 窗口_取背景管理器.
func (w *windowBase) X取背景管理器() int {
	return xc.X窗口_取背景管理器(w.X句柄)
}

// 窗口_取背景管理器扩展.
func (w *windowBase) X取背景管理器EX() int {
	return xc.X窗口_取背景管理器EX(w.X句柄)
}

// 窗口_置背景管理器.
//
// hBkInfoM: 背景管理器.
func (w *windowBase) X设置背景管理器(背景管理器 int) *windowBase {
	xc.X窗口_设置背景管理器(w.X句柄, 背景管理器)
	return w
}

// 窗口_置透明类型.
//
// nType: 窗口透明类型: xcc.Window_Transparent_.
func (w *windowBase) X设置透明类型(类型 xcc.X窗口透明标识) *windowBase {
	xc.X窗口_设置透明类型(w.X句柄, 类型)
	return w
}

// 窗口_置透明度.
//
// alpha: 窗口透明度, 范围0-255之间, 0透明, 255不透明.
func (w *windowBase) X设置透明度(透明度 byte) *windowBase {
	xc.X窗口_设置透明度(w.X句柄, 透明度)
	return w
}

// 窗口_置透明色.
//
// color: 窗口透明色, xc.RGBA 颜色.
func (w *windowBase) X设置透明色(透明色 int) *windowBase {
	xc.X窗口_设置透明色(w.X句柄, 透明色)
	return w
}

// 窗口_置阴影信息.
//
// nSize: 阴影大小.
//
// nDepth: 阴影深度, 0-255.
//
// nAngeleSize: 圆角阴影内收大小.
//
// bRightAngle: 是否强制直角.
//
// color: 阴影颜色, xc.RGBA 颜色.
func (w *windowBase) X设置阴影信息(阴影大小 int32, 阴影深度 int32, 圆角阴影内收大小 int32, 是否强制直角 bool, 阴影颜色 int) *windowBase {
	xc.X窗口_设置阴影信息(w.X句柄, 阴影大小, 阴影深度, 圆角阴影内收大小, 是否强制直角, 阴影颜色)
	return w
}

// 窗口_取阴影信息.
//
// pnSize: 阴影大小.
//
// pnDepth: 阴影深度.
//
// pnAngeleSize: 圆角阴影内收大小 .
//
// pbRightAngle: 是否强制直角.
//
// pColor: 阴影颜色, xc.RGBA 颜色.
func (w *windowBase) X取阴影信息(阴影大小, 阴影深度, 圆角阴影内收大小 *int32, 是否强制直角 *bool, 阴影颜色 *int) *windowBase {
	xc.X窗口_取阴影信息(w.X句柄, 阴影大小, 阴影深度, 圆角阴影内收大小, 是否强制直角, 阴影颜色)
	return w
}

// 窗口_取透明类型, 返回: xcc.Window_Transparent_.
func (w *windowBase) X取透明类型() xcc.X窗口透明标识 {
	return xc.X窗口_取透明类型(w.X句柄)
}

// 窗口_启用拖放文件.
//
// bEnable: 是否启用.
func (w *windowBase) X启用拖放文件(是否启用 bool) *windowBase {
	xc.X窗口_启用拖放文件(w.X句柄, 是否启用)
	return w
}

// 窗口_显示 显示隐藏窗口.
//
// bShow: 是否显示.
func (w *windowBase) X显示(是否显示 bool) *windowBase {
	xc.X窗口_显示(w.X句柄, 是否显示)
	return w
}

// 窗口_取插入符信息, 获取插入符信息, 返回: 插入符元素句柄.
//
// hWindow: 窗口句柄.
//
// pX: 接收返回x坐标.
//
// pY: 接收返回y坐标.
//
// pWidth: 接收返回宽度.
//
// pHeight: 接收返回高度.
func (w *windowBase) X取插入符信息(返回x坐标, 返回y坐标, 返回宽度, 返回高度 *int32) int {
	return xc.X窗口_取插入符信息(w.X句柄, 返回x坐标, 返回y坐标, 返回宽度, 返回高度)
}

// 窗口_置图标.
//
// hImage: 图标句柄.
func (w *windowBase) X设置图标(图标句柄 int) *windowBase {
	xc.X窗口_设置图标(w.X句柄, 图标句柄)
	return w
}

// 窗口_置标题.
//
// pTitle: 标题文本.
func (w *windowBase) X设置标题(标题文本 string) *windowBase {
	xc.X窗口_设置标题(w.X句柄, 标题文本)
	return w
}

// 窗口_置标题颜色.
//
// color: xc.RGBA 颜色.
func (w *windowBase) X设置标题颜色(ABGR颜色 int) *windowBase {
	xc.X窗口_设置标题颜色(w.X句柄, ABGR颜色)
	return w
}

// 窗口_取控制按钮, 返回按钮句柄.
//
// nFlag: xcc.Window_Style_ . 可用值: xcc.Window_Style_Btn_Min , xcc.Window_Style_Btn_Max , xcc.Window_Style_Btn_Close .
func (w *windowBase) X取控制按钮(标志 xcc.X窗口样式) int {
	return xc.X窗口_取控制按钮(w.X句柄, 标志)
}

// 窗口_取图标, 返回图标句柄.
func (w *windowBase) X取图标() int {
	return xc.X窗口_取图标(w.X句柄)
}

// 窗口_取标题, 返回标题文本.
func (w *windowBase) X取标题() string {
	return xc.X窗口_取标题(w.X句柄)
}

// 窗口_取标题颜色, 返回xc.RGBA 颜色.
func (w *windowBase) X取标题颜色() int {
	return xc.X窗口_取标题颜色(w.X句柄)
}

// 窗口_添加背景边框.
//
// nState: 组合状态.
//
// color: xc.RGBA 颜色.
//
// width: 线宽.
func (w *windowBase) X添加背景边框(组合状态 xcc.X窗口状态, 颜色 int, 线宽 int32) *windowBase {
	xc.X窗口_添加背景边框(w.X句柄, 组合状态, 颜色, 线宽)
	return w
}

// 窗口_添加背景填充.
//
// nState: 组合状态.
//
// color: xc.RGBA 颜色.
func (w *windowBase) X添加背景填充(组合状态 xcc.X窗口状态, 颜色 int) *windowBase {
	xc.X窗口_添加背景填充(w.X句柄, 组合状态, 颜色)
	return w
}

// 窗口_添加背景图片.
//
// nState: 组合状态.
//
// hImage: 图片句柄.
func (w *windowBase) X添加背景图片(组合状态 xcc.X窗口状态, 图片句柄 int) *windowBase {
	xc.X窗口_添加背景图片(w.X句柄, 组合状态, 图片句柄)
	return w
}

// 窗口_取背景对象数量.
func (w *windowBase) X取背景对象数量() int32 {
	return xc.X窗口_取背景对象数量(w.X句柄)
}

// 窗口_清空背景对象.
func (w *windowBase) X清空背景对象() *windowBase {
	xc.X窗口_清空背景对象(w.X句柄)
	return w
}

// 通知消息_窗口中弹出, 使用基础元素作为面板, 弹出一个通知消息, 返回元素句柄, 通过此句柄可对其操作.
//
// position: 位置, Position_Flag_.
//
// pTitle: 标题.
//
// pText: 内容.
//
// hIcon: 图标.
//
// skin: 外观类型, NotifyMsg_Skin_.
func (w *windowBase) X通知消息_居中(位置 xcc.X位置标识, 标题, 内容 string, 图标 int, 外观类型 xcc.X通知消息外观) int {
	return xc.X通知消息_居中(w.X句柄, 位置, 标题, 内容, 图标, 外观类型)
}

// 通知消息_窗口中弹出扩展, 使用基础元素作为面板, 弹出一个通知消息, 返回元素句柄, 通过此句柄可对其操作.
//
// position: 位置, Position_Flag_.
//
// pTitle: 标题.
//
// pText: 内容.
//
// hIcon: 图标.
//
// skin: 外观类型, NotifyMsg_Skin_.
//
// bBtnClose: 是否启用关闭按钮.
//
// bAutoClose: 是否自动关闭.
//
// nWidth: 自定义宽度, -1(使用默认值).
//
// nHeight: 自定义高度, -1(使用默认值).
func (w *windowBase) X通知消息_居中EX(位置 xcc.X位置标识, 标题, 内容 string, 图标 int, 外观类型 xcc.X通知消息外观, 启用关闭按钮, 自动关闭 bool, 自定义宽, 自定义高 int) int {
	return xc.X通知消息_窗口中弹出EX(w.X句柄, 位置, 标题, 内容, 图标, 外观类型, 启用关闭按钮, 自动关闭, 自定义宽, 自定义高)
}

// 通知消息_置持续时间.
//
// duration: 持续时间.
func (w *windowBase) X通知消息_设置持续时间(持续时间 uint32) *windowBase {
	xc.X通知消息_设置持续时间(w.X句柄, 持续时间)
	return w
}

// 通知消息_置父边距 设置通知消息与父对象的四边间隔.
//
// left: 左侧间隔, 未实现, 预留功能.
//
// top: 顶部间隔.
//
// right: 右侧间隔.
//
// bottom: 底部间隔, 未实现, 预留功能.
func (w *windowBase) X通知消息_设置父边距(左侧, 顶部, 右侧, 底部 int32) *windowBase {
	xc.X通知消息_设置父边距(w.X句柄, 左侧, 顶部, 右侧, 底部)
	return w
}

// 通知消息_置标题高度.
//
// nHeight: 高度.
func (w *windowBase) X通知消息_设置标题高(高度 int32) *windowBase {
	xc.X通知消息_设置标题高(w.X句柄, 高度)
	return w
}

// 通知消息_置宽度, 设置默认宽度.
//
// nWidth: 宽度.
func (w *windowBase) X通知消息_设置宽(宽度 int32) *windowBase {
	xc.X通知消息_设置宽(w.X句柄, 宽度)
	return w
}

// 通知消息_置间隔.
//
// nSpace: 间隔大小.
func (w *windowBase) X通知消息_设置间隔(间隔大小 int32) *windowBase {
	xc.X通知消息_设置间隔(w.X句柄, 间隔大小)
	return w
}

// 通知消息_置边大小, 设置通知消息面板边大小.
//
// left: 左边.
//
// top: 顶边.
//
// right: 右边.
//
// bottom: 底边.
func (w *windowBase) X通知消息_设置边大小(左边, 顶边, 右边, 底边 int32) *windowBase {
	xc.X通知消息_设置边大小(w.X句柄, 左边, 顶边, 右边, 底边)
	return w
}

// 窗口_置背景, 返回设置的背景对象数量.
//
// pText: 背景内容字符串.
func (w *windowBase) X设置背景文本(文本 string) int32 {
	return xc.X窗口_设置背景(w.X句柄, 文本)
}

// 窗口_是否可拖动标题栏.
func (w *windowBase) X是否可拖动标题栏() bool {
	return xc.X窗口_是否可拖动标题栏(w.X句柄)
}

// 窗口_是否可拖动窗口.
func (w *windowBase) X是否可拖动窗口() bool {
	return xc.X窗口_是否可拖动窗口(w.X句柄)
}

// 窗口_是否可拖动边框.
func (w *windowBase) X是否可拖动边框() bool {
	return xc.X窗口_是否可拖动边框(w.X句柄)
}

// 窗口_置标题外间距, 设置标题内容(图标, 标题, 控制按钮)外间距.
//
// left: 左边间距.
//
// top: 上边间距.
//
// right: 右边间距.
//
// bottom: 下边间距.
func (w *windowBase) X设置标题外间距(左, 上, 右, 下 int32) *windowBase {
	xc.X窗口_设置标题外间距(w.X句柄, 左, 上, 右, 下)
	return w
}

// SetTopEx 窗口_置顶Ex.
//
// b: 是否置顶.
func (w *windowBase) X窗口置顶(置顶 bool) bool {
	return wnd.X窗口置顶(w.X取HWND句柄(), 置顶)
}

// 窗口_置窗口位置. 封装系统API X设置窗口位置(), 内部做了DPI适配.
//
// hWndInsertAfter: 在Z序中位于定位窗口之前的窗口句柄. 此参数必须是窗口HWND或以下值之一: xcc.HWND_.
//
// x: X坐标.
//
// y: Y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// uFlags: 窗口大小调整和定位标志. 可以是以下值的组合: xcc.SWP_.
func (w *windowBase) X设置窗口位置(置顶方式 xcc.X窗口置顶, X坐标, Y坐标, 宽, 高 int32, 标志 xcc.X窗口大小定位标识) bool {
	return xc.X窗口_设置窗口位置(w.X句柄, 置顶方式, X坐标, Y坐标, 宽, 高, 标志)
}

// 窗口_取DPI. 获取当前窗口所在显示器DPI, 返回窗口DPI.
func (w *windowBase) X取DPI() int32 {
	return xc.X窗口_取DPI(w.X句柄)
}

// 窗口_坐标转换DPI. 窗口客户区坐标转换到缩放后DPI坐标.
//
// pRect: 接收返回坐标.
func (w *windowBase) X坐标转换DPI(返回矩形 *xc.X结构_矩形) *windowBase {
	xc.X窗口_坐标转换DPI(w.X句柄, 返回矩形)
	return w
}

// 窗口_坐标点转换DPI. 窗口客户区坐标点转换到缩放后.
//
// pPt: 接收返回坐标点.
func (w *windowBase) X坐标点转换DPI(返回坐标 *xc.X结构_坐标) *windowBase {
	xc.X窗口_坐标点转换DPI(w.X句柄, 返回坐标)
	return w
}

// 窗口_取光标位置. 封装的系统API: X取光标位置(), 内部做了DPI适配.
//
// pPt: 接收返回坐标点.
func (w *windowBase) X取光标位置(返回坐标 *xc.X结构_坐标) bool {
	return xc.X窗口_取光标位置(w.X句柄, 返回坐标)
}

// 窗口_客户区坐标点到屏幕坐标点. 封装的系统API: X客户区坐标点到屏幕坐标点, 内部做了DPI适配.
//
// pPt: 接收返回坐标点.
func (w *windowBase) X客户区坐标点到屏幕坐标点(返回坐标 *xc.X结构_坐标) bool {
	return xc.X窗口_客户区坐标点到屏幕坐标点(w.X句柄, 返回坐标)
}

// 窗口_屏幕坐标点到客户区坐标点. 封装的系统API: X屏幕坐标点到客户区坐标点(), 内部做了DPI适配.
//
// pPt: 接收返回坐标点.
func (w *windowBase) X屏幕坐标点到客户区坐标点(返回坐标 *xc.X结构_坐标) bool {
	return xc.X窗口_屏幕坐标点到客户区坐标点(w.X句柄, 返回坐标)
}

// 窗口_置DPI. 设置当前窗口DPI, 默认DPI为96.
//
// nDPI: DPI值.
func (w *windowBase) X设置DPI(DPI值 int32) *windowBase {
	xc.X窗口_设置DPI(w.X句柄, DPI值)
	return w
}

// 窗口_销毁.
func (w *windowBase) DestroyWindow() *windowBase {
	xc.XWnd_DestroyWindow(w.X句柄)
	return w
}

// 窗口_置大小. 设置窗口宽高.
//
// 宽: width.
//
// 高: height.
func (w *windowBase) X设置大小(宽, 高 int32) *windowBase {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	rc.X右 = rc.X左 + 宽
	rc.X下 = rc.X上 + 高
	xc.X窗口_设置坐标(w.X句柄, &rc)
	return w
}

// 窗口_置宽度.
//
// 宽: width.
func (w *windowBase) X设置宽度(宽 int32) *windowBase {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	rc.X右 = rc.X左 + 宽
	xc.X窗口_设置坐标(w.X句柄, &rc)
	return w
}

// 窗口_置高度.
//
// 高: height.
func (w *windowBase) X设置高度(高 int32) *windowBase {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	rc.X下 = rc.X上 + 高
	xc.X窗口_设置坐标(w.X句柄, &rc)
	return w
}

// 窗口_取宽度.
func (w *windowBase) X取宽度() int32 {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc.X右 - rc.X左
}

// 窗口_取高度.
func (w *windowBase) X取高度() int32 {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc.X下 - rc.X上
}

// 窗口_取左边.
func (w *windowBase) X取左边() int32 {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc.X左
}

// 窗口_取顶边.
func (w *windowBase) X取顶边() int32 {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc.X上
}

// 窗口_取右边.
func (w *windowBase) X取右边() int32 {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc.X右
}

// 窗口_取底边.
func (w *windowBase) X取底边() int32 {
	var rc xc.X结构_矩形
	xc.X窗口_取坐标(w.X句柄, &rc)
	return rc.X下
}

// 窗口_置左边.
//
// x: 左边x坐标.
func (w *windowBase) X设置左边(x坐标 int32) *windowBase {
	rc := w.X取坐标EX()
	width := rc.X右 - rc.X左
	rc.X左 = x坐标
	rc.X右 = rc.X左 + width
	xc.X窗口_设置坐标(w.X句柄, &rc)
	return w
}

// 窗口_置顶边.
//
// y: 顶边y坐标.
func (w *windowBase) X设置顶边(y坐标 int32) *windowBase {
	rc := w.X取坐标EX()
	height := rc.X下 - rc.X上
	rc.X上 = y坐标
	rc.X下 = rc.X上 + height
	xc.X窗口_设置坐标(w.X句柄, &rc)
	return w
}

// 窗口_置左边和顶边.
//
// x: 左边x坐标.
//
// y: 顶边y坐标.
func (w *windowBase) SetLeftAndTop(x, y int32) *windowBase {
	rc := w.X取坐标EX()
	width := rc.X右 - rc.X左
	height := rc.X下 - rc.X上
	rc.X左 = x
	rc.X上 = y
	rc.X右 = rc.X左 + width
	rc.X下 = rc.X上 + height
	xc.X窗口_设置坐标(w.X句柄, &rc)
	return w
}

// CreateTrayIcon 创建托盘图标对象. 之后需调用托盘图标对象的Show函数来显示到托盘.
//
// hIcon: 图标句柄. 可使用 wutil.HIcon 函数生成.
//
// tips: 提示文本, 长度不能超过 127 个字符.
func (w *windowBase) X创建托盘图标(图标句柄 uintptr, 提示 string) *X结构_托盘 {
	return X创建托盘图标(w.X句柄, 图标句柄, 提示)
}

/*
LayoutBox-布局盒子
*/

// EnableHorizon 布局盒子_启用水平.
//
// bEnable: 是否启用.
func (w *windowBase) X启用水平(是否启用 bool) *windowBase {
	xc.X布局盒子_启用水平(w.X句柄, 是否启用)
	return w
}

// EnableAutoWrap 布局盒子_启用自动换行.
//
// bEnable: 是否启用.
func (w *windowBase) X启用自动换行(是否启用 bool) *windowBase {
	xc.X布局盒子_启用自动换行(w.X句柄, 是否启用)
	return w
}

// EnableOverflowHide 布局盒子_启用溢出隐藏.
//
// bEnable: 是否启用.
func (w *windowBase) X启用溢出隐藏(是否启用 bool) *windowBase {
	xc.X布局盒子_启用溢出隐藏(w.X句柄, 是否启用)
	return w
}

// SetAlignH 布局盒子_置水平对齐.
//
// nAlign: 对齐方式: xcc.Layout_Align_.
func (w *windowBase) X设置水平对齐(对齐方式 xcc.X布局对齐) *windowBase {
	xc.X布局盒子_设置水平对齐(w.X句柄, 对齐方式)
	return w
}

// SetAlignV 布局盒子_置垂直对齐.
//
// nAlign: 对齐方式: xcc.Layout_Align_.
func (w *windowBase) X设置垂直对齐(方式 xcc.X布局对齐) *windowBase {
	xc.X布局盒子_设置垂直对齐(w.X句柄, 方式)
	return w
}

// SetAlignBaseline 布局盒子_置对齐基线.
//
// nAlign: 对齐方式: xcc.Layout_Align_Axis_.
func (w *windowBase) X设置对齐基线(方式 xcc.X布局轴对齐) *windowBase {
	xc.X布局盒子_设置对齐基线(w.X句柄, 方式)
	return w
}

// SetSpace 布局盒子_置间距.
//
// nSpace: 项间距大小.
func (w *windowBase) X设置间距(项间距大小 int32) *windowBase {
	xc.X布局盒子_设置间距(w.X句柄, 项间距大小)
	return w
}

// SetSpaceRow 布局盒子_置行距.
//
// nSpace: 行间距大小.
func (w *windowBase) X设置行距(间距 int32) *windowBase {
	xc.X布局盒子_设置行距(w.X句柄, 间距)
	return w
}

// DpiConv 将int32类型的整数根据窗口dpi进行换算.
//   - 开启自动DPI后, 你可能感觉到一些函数获取的坐标不对了, 因为你在用高分辨率屏幕, 然后系统里会有个缩放的设置, 可能是150%, 这时获取到的坐标应该乘以1.5才是屏幕上显示的真实的坐标.
//
// i: int32类型的整数.
func (w *windowBase) DpiConv(i int32) int32 {
	return xc.DpiConv(w.X取DPI(), i)
}

// ------------------------- 事件 ------------------------- //

type X事件_托盘图标 func(wParam, lParam uintptr, pbHandled *bool) int // 托盘图标事件.

type X事件_消息过程 func(message uint32, wParam, lParam uintptr, pbHandled *bool) int               // 窗口消息过程.
type X事件_消息过程1 func(hWindow int, message uint32, wParam, lParam uintptr, pbHandled *bool) int // 窗口消息过程.
type X事件_炫彩定时器 func(nTimerID uint, pbHandled *bool) int                                        // 炫彩定时器, 非系统定时器, 注册消息XWM_TIMER接收.
type X事件_炫彩定时器1 func(hWindow int, nTimerID uint, pbHandled *bool) int                          // 炫彩定时器, 非系统定时器, 注册消息XWM_TIMER接收.
type X事件_设置焦点 func(hEle int, pbHandled *bool) int                                         // 窗口事件_置焦点元素. 指定元素获得焦点
type X事件_设置焦点1 func(hWindow int, hEle int, pbHandled *bool) int                           // 窗口事件_置焦点元素. 指定元素获得焦点
type X事件_浮动窗格 func(hFloatWnd int, hPane int, pbHandled *bool) int                           // 浮动窗格.
type X事件_浮动窗格1 func(hWindow int, hFloatWnd int, hPane int, pbHandled *bool) int             // 浮动窗格.
type X事件_绘制完成 func(hDraw int, pbHandled *bool) int                                           // 窗口绘制完成消息.
type X事件_绘制完成1 func(hWindow int, hDraw int, pbHandled *bool) int                             // 窗口绘制完成消息.
type X事件_绘制完成并显示 func(pbHandled *bool) int                                                  // 窗口绘制完成并且已经显示到屏幕.
type X事件_绘制完成并显示1 func(hWindow int, pbHandled *bool) int                                    // 窗口绘制完成并且已经显示到屏幕.
type X事件_框架窗口码头弹出窗格 func(hWindowDock, hPane int, pbHandled *bool) int                             // 框架窗口码头弹出窗格, 当用户点击码头上的按钮时, 显示对应的窗格, 当失去焦点时自动隐藏窗格.
type X事件_框架窗口码头弹出窗格1 func(hWindow int, hWindowDock, hPane int, pbHandled *bool) int               // 框架窗口码头弹出窗格, 当用户点击码头上的按钮时, 显示对应的窗格, 当失去焦点时自动隐藏窗格.
type X事件_框架窗口主视图坐标改变 func(width, height int32, pbHandled *bool) int                             // 框架窗口主视图坐标改变, 如果主视图没有绑定元素, 那么当坐标改变时触发此事件
type X事件_框架窗口主视图坐标改变1 func(hWindow int, width, height int32, pbHandled *bool) int               // 框架窗口主视图坐标改变, 如果主视图没有绑定元素, 那么当坐标改变时触发此事件

// 浮动窗口拖动, 用户拖动浮动窗口移动, 显示停靠提示.
//
// hFloatWnd: 拖动的浮动窗口句柄.
//
// hArray: HWINDOW array[6], 窗格停靠提示窗口句柄数组, 有6个成员, 分别为:[0]中间十字, [1]左侧, [2]顶部, [3]右侧, [4]底部, [5]停靠位置预览.
type X事件_浮动窗口拖动 func(hFloatWnd int, hArray *[6]int, pbHandled *bool) int

// 浮动窗口拖动, 用户拖动浮动窗口移动, 显示停靠提示.
//
// hWindow: 传入的窗口资源句柄.
//
// hFloatWnd: 拖动的浮动窗口句柄.
//
// hArray: HWINDOW array[6], 窗格停靠提示窗口句柄数组, 有6个成员, 分别为:[0]中间十字, [1]左侧, [2]顶部, [3]右侧, [4]底部, [5]停靠位置预览.
type X事件_浮动窗口拖动1 func(hWindow int, hFloatWnd int, hArray *[6]int, pbHandled *bool) int

type X事件_绘制 func(hDraw int, pbHandled *bool) int                                        // 窗口绘制消息.
type X事件_绘制1 func(hWindow int, hDraw int, pbHandled *bool) int                          // 窗口绘制消息.
type X事件_关闭 func(pbHandled *bool) int                                                   // 窗口关闭消息.
type X事件_关闭1 func(hWindow int, pbHandled *bool) int                                     // 窗口关闭消息.
type X事件_销毁 func(pbHandled *bool) int                                                 // 窗口销毁消息.
type X事件_销毁1 func(hWindow int, pbHandled *bool) int                                   // 窗口销毁消息.
type X事件_非客户区销毁 func(pbHandled *bool) int                                               // 窗口非客户区销毁消息.
type X事件_非客户区销毁1 func(hWindow int, pbHandled *bool) int                                 // 窗口非客户区销毁消息.
type X事件_鼠标移动 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                   // 窗口鼠标移动消息.
type X事件_鼠标移动1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int     // 窗口鼠标移动消息.
type X事件_鼠标左键按下 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                 // 窗口鼠标左键按下消息.
type X事件_鼠标左键按下1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int   // 窗口鼠标左键按下消息.
type X事件_鼠标左键弹起 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                   // 窗口鼠标左键弹起消息.
type X事件_鼠标左键弹起1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int     // 窗口鼠标左键弹起消息.
type X事件_鼠标右键按下 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                 // 窗口鼠标右键按下消息.
type X事件_鼠标右键按下1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int   // 窗口鼠标右键按下消息.
type X事件_鼠标右键弹起 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                   // 窗口鼠标右键弹起消息.
type X事件_鼠标右键弹起1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int     // 窗口鼠标右键弹起消息.
type X事件_鼠标左键双击 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int               // 窗口鼠标左键双击消息.
type X事件_鼠标左键双击1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int // 窗口鼠标左键双击消息.
type X事件_鼠标右键双击 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int               // 窗口鼠标右键双击消息.
type X事件_鼠标右键双击1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int // 窗口鼠标右键双击消息.
type X事件_鼠标滚轮滚动 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                  // 窗口鼠标滚轮滚动消息.
type X事件_鼠标滚轮滚动1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int    // 窗口鼠标滚轮滚动消息.
type X事件_退出移动或调整大小模式循环改 func(pbHandled *bool) int                                            // 窗口退出移动或调整大小模式循环改，详情参见MSDN.
type X事件_退出移动或调整大小模式循环改1 func(hWindow int, pbHandled *bool) int                              // 窗口退出移动或调整大小模式循环改，详情参见MSDN.
type X事件_鼠标进入 func(nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int                  // 窗口鼠标进入消息.
type X事件_鼠标进入1 func(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int    // 窗口鼠标进入消息.
type X事件_鼠标离开 func(pbHandled *bool) int                                              // 窗口鼠标离开消息.
type X事件_鼠标离开1 func(hWindow int, pbHandled *bool) int                                // 窗口鼠标离开消息.
type X事件_大小改变 func(nFlags uint, pPt *xc.X结构_大小, pbHandled *bool) int                         // 窗口大小改变消息.
type X事件_大小改变1 func(hWindow int, nFlags uint, pPt *xc.X结构_大小, pbHandled *bool) int           // 窗口大小改变消息.
type X事件_定时器 func(nIDEvent uint, pbHandled *bool) int                                    // 窗口定时器消息.
type X事件_定时器1 func(hWindow int, nIDEvent uint, pbHandled *bool) int                      // 窗口定时器消息.
type X事件_获得焦点 func(pbHandled *bool) int                                                // 窗口获得焦点.
type X事件_获得焦点1 func(hWindow int, pbHandled *bool) int                                  // 窗口获得焦点.
type X事件_失去焦点 func(pbHandled *bool) int                                               // 窗口失去焦点.
type X事件_失去焦点1 func(hWindow int, pbHandled *bool) int                                 // 窗口失去焦点.
type X事件_键盘按键 func(wParam, lParam uintptr, pbHandled *bool) int                         // 窗口键盘按键消息.
type X事件_键盘按键1 func(hWindow int, wParam, lParam uintptr, pbHandled *bool) int           // 窗口键盘按键消息.
type X事件_鼠标捕获改变 func(hWnd uintptr, pbHandled *bool) int                            // 窗口鼠标捕获改变消息.
type X事件_鼠标捕获改变1 func(hWindow int, hWnd uintptr, pbHandled *bool) int              // 窗口鼠标捕获改变消息.
type X事件_设置鼠标光标 func(wParam, lParam uintptr, pbHandled *bool) int                       // 窗口设置鼠标光标.
type X事件_设置鼠标光标1 func(hWindow int, wParam, lParam uintptr, pbHandled *bool) int         // 窗口设置鼠标光标.
type X事件_字符消息 func(wParam, lParam uintptr, pbHandled *bool) int                            // 窗口字符消息.
type X事件_字符消息1 func(hWindow int, wParam, lParam uintptr, pbHandled *bool) int              // 窗口字符消息.
type X事件_拖动文件到窗口 func(hDropInfo uintptr, pbHandled *bool) int                            // 拖动文件到窗口.
type X事件_拖动文件到窗口1 func(hWindow int, hDropInfo uintptr, pbHandled *bool) int              // 拖动文件到窗口.

// 托盘图标事件.
func (w *windowBase) X事件_托盘图标(回调函数 X事件_托盘图标) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_托盘_图标, 回调函数)
}

// 窗口消息过程.
func (w *windowBase) X事件_消息过程(回调函数 X事件_消息过程) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_消息过程, 回调函数)
}

// 窗口消息过程.
func (w *windowBase) X事件_消息过程1(回调函数 X事件_消息过程1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_消息过程, 回调函数)
}

// 炫彩定时器, 非系统定时器, 注册消息XWM_TIMER接收.
func (w *windowBase) X事件_炫彩定时器(回调函数 X事件_炫彩定时器) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_炫彩定时器, 回调函数)
}

// 炫彩定时器, 非系统定时器, 注册消息XWM_TIMER接收.
func (w *windowBase) X事件_炫彩定时器1(回调函数 X事件_炫彩定时器1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_炫彩定时器, 回调函数)
}

// 窗口事件_置焦点元素. 指定元素获得焦点.
func (w *windowBase) X事件_设置焦点(回调函数 X事件_设置焦点) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_置焦点, 回调函数)
}

// 窗口事件_置焦点元素. 指定元素获得焦点.
func (w *windowBase) X事件_设置焦点1(回调函数 X事件_设置焦点1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_置焦点, 回调函数)
}

// 浮动窗格.
func (w *windowBase) X事件_浮动窗格(回调函数 X事件_浮动窗格) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗格_浮动, 回调函数)
}

// 浮动窗格.
func (w *windowBase) X事件_浮动窗格1(回调函数 X事件_浮动窗格1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗格_浮动, 回调函数)
}

// 窗口绘制完成消息.
func (w *windowBase) X事件_绘制完成(回调函数 X事件_绘制完成) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_绘制完成, 回调函数)
}

// 窗口绘制完成消息.
func (w *windowBase) X事件_绘制完成1(回调函数 X事件_绘制完成1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_绘制完成, 回调函数)
}

// 窗口绘制完成并且已经显示到屏幕.
func (w *windowBase) X事件_绘制完成并显示(回调函数 X事件_绘制完成并显示) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_绘制完成并显示, 回调函数)
}

// 窗口绘制完成并且已经显示到屏幕.
func (w *windowBase) X事件_绘制完成并显示1(回调函数 X事件_绘制完成并显示1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_绘制完成并显示, 回调函数)
}

// 框架窗口码头弹出窗格, 当用户点击码头上的按钮时, 显示对应的窗格, 当失去焦点时自动隐藏窗格.
func (w *windowBase) X事件_框架窗口码头弹出窗格(回调函数 X事件_框架窗口码头弹出窗格) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_框架窗口_码头弹出窗格, 回调函数)
}

// 框架窗口码头弹出窗格, 当用户点击码头上的按钮时, 显示对应的窗格, 当失去焦点时自动隐藏窗格.
func (w *windowBase) X事件_框架窗口码头弹出窗格1(回调函数 X事件_框架窗口码头弹出窗格1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_框架窗口_码头弹出窗格, 回调函数)
}

// 框架窗口主视图坐标改变, 如果主视图没有绑定元素, 那么当坐标改变时触发此事件.
func (w *windowBase) X事件_框架窗口主视图坐标改变(回调函数 X事件_框架窗口主视图坐标改变) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_框架窗口_主视图坐标改变, 回调函数)
}

// 框架窗口主视图坐标改变, 如果主视图没有绑定元素, 那么当坐标改变时触发此事件.
func (w *windowBase) X事件_框架窗口主视图坐标改变1(回调函数 X事件_框架窗口主视图坐标改变) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_框架窗口_主视图坐标改变, 回调函数)
}

// 浮动窗口拖动, 用户拖动浮动窗口移动, 显示停靠提示.
//
// hFloatWnd: 拖动的浮动窗口句柄.
//
// hArray: HWINDOW array[6], 窗格停靠提示窗口句柄数组, 有6个成员, 分别为:[0]中间十字, [1]左侧, [2]顶部, [3]右侧, [4]底部, [5]停靠位置预览.
func (w *windowBase) X事件_浮动窗口拖动(回调函数 X事件_浮动窗口拖动) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_浮动窗口拖动, 回调函数)
}

// 浮动窗口拖动, 用户拖动浮动窗口移动, 显示停靠提示.
//
// hWindow: 传入的窗口资源句柄.
//
// hFloatWnd: 拖动的浮动窗口句柄.
//
// hArray: HWINDOW array[6], 窗格停靠提示窗口句柄数组, 有6个成员, 分别为:[0]中间十字, [1]左侧, [2]顶部, [3]右侧, [4]底部, [5]停靠位置预览.
func (w *windowBase) X事件_浮动窗口拖动1(回调函数 X事件_浮动窗口拖动1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_浮动窗口拖动, 回调函数)
}

// 窗口绘制消息.
func (w *windowBase) X事件_绘制(回调函数 X事件_绘制) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_绘制, 回调函数)
}

// 窗口绘制消息.
func (w *windowBase) X事件_绘制1(回调函数 X事件_绘制1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_绘制, 回调函数)
}

// 窗口关闭消息.
func (w *windowBase) X事件_关闭(回调函数 X事件_关闭) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_关闭, 回调函数)
}

// 窗口关闭消息.
func (w *windowBase) X事件_关闭1(回调函数 X事件_关闭1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_关闭, 回调函数)
}

// 窗口销毁消息.
func (w *windowBase) X事件_销毁(回调函数 X事件_销毁) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_销毁, 回调函数)
}

// 窗口销毁消息.
func (w *windowBase) X事件_销毁1(回调函数 X事件_销毁1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_销毁, 回调函数)
}

// 窗口非客户区销毁消息.
func (w *windowBase) X事件_非客户区销毁(回调函数 X事件_非客户区销毁) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_非客户区销毁, 回调函数)
}

// 窗口非客户区销毁消息.
func (w *windowBase) X事件_非客户区销毁1(回调函数 X事件_非客户区销毁1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_非客户区销毁, 回调函数)
}

// 窗口鼠标移动消息.
func (w *windowBase) X事件_鼠标移动(回调函数 X事件_鼠标移动) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_移动, 回调函数)
}

// 窗口鼠标移动消息.
func (w *windowBase) X事件_鼠标移动1(回调函数 X事件_鼠标移动1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_移动, 回调函数)
}

// 窗口鼠标左键按下消息.
func (w *windowBase) X事件_鼠标左键按下(回调函数 X事件_鼠标左键按下) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_左键按下, 回调函数)
}

// 窗口鼠标左键按下消息.
func (w *windowBase) X事件_鼠标左键按下1(回调函数 X事件_鼠标左键按下1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_左键按下, 回调函数)
}

// 窗口鼠标左键弹起消息.
func (w *windowBase) X事件_鼠标左键弹起(回调函数 X事件_鼠标左键弹起) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_左键弹起, 回调函数)
}

// 窗口鼠标左键弹起消息.
func (w *windowBase) X事件_鼠标左键弹起1(回调函数 X事件_鼠标左键弹起1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_左键弹起, 回调函数)
}

// 窗口鼠标右键按下消息.
func (w *windowBase) X事件_鼠标右键按下(回调函数 X事件_鼠标右键按下) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_右键按下, 回调函数)
}

// 窗口鼠标右键按下消息.
func (w *windowBase) X事件_鼠标右键按下1(回调函数 X事件_鼠标右键按下1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_右键按下, 回调函数)
}

// 窗口鼠标右键弹起消息.
func (w *windowBase) X事件_鼠标右键弹起(回调函数 X事件_鼠标右键弹起) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_右键弹起, 回调函数)
}

// 窗口鼠标右键弹起消息.
func (w *windowBase) X事件_鼠标右键弹起1(回调函数 X事件_鼠标右键弹起1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_右键弹起, 回调函数)
}

// 窗口鼠标左键双击消息.
func (w *windowBase) X事件_鼠标左键双击(回调函数 X事件_鼠标左键双击) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_左键双击, 回调函数)
}

// 窗口鼠标左键双击消息.
func (w *windowBase) X事件_鼠标左键双击1(回调函数 X事件_鼠标左键双击1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_左键双击, 回调函数)
}

// 窗口鼠标右键双击消息.
func (w *windowBase) X事件_鼠标右键双击(回调函数 X事件_鼠标右键双击) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_右键双击, 回调函数)
}

// 窗口鼠标右键双击消息.
func (w *windowBase) X事件_鼠标右键双击1(回调函数 X事件_鼠标右键双击1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_右键双击, 回调函数)
}

// 窗口鼠标滚轮滚动消息.
func (w *windowBase) X事件_鼠标滚轮滚动(回调函数 X事件_鼠标滚轮滚动) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_滚轮滚动, 回调函数)
}

// 窗口鼠标滚轮滚动消息.
func (w *windowBase) X事件_鼠标滚轮滚动1(回调函数 X事件_鼠标滚轮滚动1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_滚轮滚动, 回调函数)
}

// 窗口退出移动或调整大小模式循环改，详情参见MSDN.
func (w *windowBase) X事件_退出移动或调整大小模式循环改(回调函数 X事件_退出移动或调整大小模式循环改) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_退出移动或调整大小模式循环改, 回调函数)
}

// 窗口退出移动或调整大小模式循环改，详情参见MSDN.
func (w *windowBase) X事件_退出移动或调整大小模式循环改1(回调函数 X事件_退出移动或调整大小模式循环改1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_退出移动或调整大小模式循环改, 回调函数)
}

// 窗口鼠标进入消息.
func (w *windowBase) X事件_鼠标进入(回调函数 X事件_鼠标进入) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_鼠标进入, 回调函数)
}

// 窗口鼠标进入消息.
func (w *windowBase) X事件_鼠标进入1(回调函数 X事件_鼠标进入1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_鼠标进入, 回调函数)
}

// 窗口鼠标离开消息.
func (w *windowBase) X事件_鼠标离开(回调函数 X事件_鼠标离开) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_鼠标离开, 回调函数)
}

// 窗口鼠标离开消息.
func (w *windowBase) X事件_鼠标离开1(回调函数 X事件_鼠标离开1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_鼠标离开, 回调函数)
}

// 窗口大小改变消息.
func (w *windowBase) X事件_大小改变(回调函数 X事件_大小改变) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_大小改变, 回调函数)
}

// 窗口大小改变消息.
func (w *windowBase) X事件_大小改变1(回调函数 X事件_大小改变1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_大小改变, 回调函数)
}

// 窗口定时器消息.
func (w *windowBase) X事件_定时器(回调函数 X事件_定时器) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_定时器, 回调函数)
}

// 窗口定时器消息.
func (w *windowBase) X事件_定时器1(回调函数 X事件_定时器1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_定时器, 回调函数)
}

// 窗口获得焦点.
func (w *windowBase) X事件_获得焦点(回调函数 X事件_获得焦点) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_获得焦点, 回调函数)
}

// 窗口获得焦点.
func (w *windowBase) X事件_获得焦点1(回调函数 X事件_获得焦点1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_获得焦点, 回调函数)
}

// 窗口失去焦点.
func (w *windowBase) X事件_失去焦点(回调函数 X事件_失去焦点) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_窗口_失去焦点, 回调函数)
}

// 窗口失去焦点.
func (w *windowBase) X事件_失去焦点1(回调函数 X事件_失去焦点1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_窗口_失去焦点, 回调函数)
}

// 窗口键盘按键消息.
func (w *windowBase) X事件_键盘按键(回调函数 X事件_键盘按键) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_键盘_按键, 回调函数)
}

// 窗口键盘按键消息.
func (w *windowBase) X事件_键盘按键1(回调函数 X事件_键盘按键1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_键盘_按键, 回调函数)
}

// 窗口鼠标捕获改变消息.
func (w *windowBase) X事件_鼠标捕获改变(回调函数 X事件_鼠标捕获改变) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_捕获改变, 回调函数)
}

// 窗口鼠标捕获改变消息.
func (w *windowBase) X事件_鼠标捕获改变1(回调函数 X事件_鼠标捕获改变1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_捕获改变, 回调函数)
}

// 窗口设置鼠标光标.
func (w *windowBase) X事件_设置鼠标光标(回调函数 X事件_设置鼠标光标) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_鼠标_设置光标, 回调函数)
}

// 窗口设置鼠标光标.
func (w *windowBase) X事件_设置鼠标光标1(回调函数 X事件_设置鼠标光标1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_鼠标_设置光标, 回调函数)
}

// 窗口字符消息.
func (w *windowBase) X事件_字符消息(回调函数 X事件_字符消息) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_字符, 回调函数)
}

// 窗口字符消息.
func (w *windowBase) X事件_字符消息1(回调函数 X事件_字符消息1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_字符, 回调函数)
}

// 拖动文件到窗口.
func (w *windowBase) X事件_拖动文件到窗口(回调函数 X事件_拖动文件到窗口) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_拖动文件到窗口, 回调函数)
}

// 拖动文件到窗口.
func (w *windowBase) X事件_拖动文件到窗口1(回调函数 X事件_拖动文件到窗口1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_拖动文件到窗口, 回调函数)
}

type X事件_菜单弹出 func(hMenu int, pbHandled *bool) int                                                         // 菜单弹出.
type X事件_菜单弹出1 func(hWindow int, hMenu int, pbHandled *bool) int                                           // 菜单弹出.
type X事件_菜单弹出窗口 func(hMenu int, pInfo *xc.X结构_菜单弹出窗口, pbHandled *bool) int                           // 菜单弹出窗口.
type X事件_菜单弹出窗口1 func(hWindow int, hMenu int, pInfo *xc.X结构_菜单弹出窗口, pbHandled *bool) int             // 菜单弹出窗口.
type X事件_菜单选择 func(nID int32, pbHandled *bool) int                                                        // 菜单选择.
type X事件_菜单选择1 func(hWindow int, nID int32, pbHandled *bool) int                                          // 菜单选择.
type X事件_菜单退出 func(pbHandled *bool) int                                                                     // 菜单退出.
type X事件_菜单退出1 func(hWindow int, pbHandled *bool) int                                                       // 菜单退出.
type X事件_绘制菜单背景 func(hDraw int, pInfo *xc.X结构_菜单背景自绘, pbHandled *bool) int               // 绘制菜单背景, 启用该功能需要调用XMenu_EnableDrawBackground().
type X事件_绘制菜单背景1 func(hWindow int, hDraw int, pInfo *xc.X结构_菜单背景自绘, pbHandled *bool) int // 绘制菜单背景, 启用该功能需要调用XMenu_EnableDrawBackground().
type X事件_绘制菜单项 func(hDraw int, pInfo *xc.X结构_菜单项自绘, pbHandled *bool) int                            // 绘制菜单项事件, 启用该功能需要调用XMenu_EnableDrawItem().
type X事件_绘制菜单项1 func(hWindow int, hDraw int, pInfo *xc.X结构_菜单项自绘, pbHandled *bool) int              // 绘制菜单项事件, 启用该功能需要调用XMenu_EnableDrawItem().

// 菜单弹出.
func (w *windowBase) X事件_菜单弹出(回调函数 X事件_菜单弹出) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_菜单_弹出, 回调函数)
}

// 菜单弹出.
func (w *windowBase) X事件_菜单弹出1(回调函数 X事件_菜单弹出1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_菜单_弹出, 回调函数)
}

// 菜单弹出窗口.
func (w *windowBase) X事件_菜单弹出窗口(回调函数 X事件_菜单弹出窗口) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_菜单_弹出窗口, 回调函数)
}

// 菜单弹出窗口.
func (w *windowBase) X事件_菜单弹出窗口1(回调函数 X事件_菜单弹出窗口1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_菜单_弹出窗口, 回调函数)
}

// 菜单选择.
func (w *windowBase) X事件_菜单选择(回调函数 X事件_菜单选择) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_菜单_选择, 回调函数)
}

// 菜单选择.
func (w *windowBase) X事件_菜单选择1(回调函数 X事件_菜单选择1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_菜单_选择, 回调函数)
}

// 菜单退出.
func (w *windowBase) X事件_菜单退出(回调函数 X事件_菜单退出) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_菜单_退出, 回调函数)
}

// 菜单退出.
func (w *windowBase) X事件_菜单退出1(回调函数 X事件_菜单退出1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_菜单_退出, 回调函数)
}

// 绘制菜单背景, 启用该功能需要调用XMenu_EnableDrawBackground().
func (w *windowBase) X事件_绘制菜单背景(回调函数 X事件_绘制菜单背景) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_菜单_绘制背景, 回调函数)
}

// 绘制菜单背景, 启用该功能需要调用XMenu_EnableDrawBackground().
func (w *windowBase) X事件_绘制菜单背景1(回调函数 X事件_绘制菜单背景1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_菜单_绘制背景, 回调函数)
}

// 绘制菜单项事件, 启用该功能需要调用XMenu_EnableDrawItem().
func (w *windowBase) X事件_绘制菜单项(回调函数 X事件_绘制菜单项) bool {
	return xc.X窗口_注册事件C(w.X句柄, xcc.X窗口事件_菜单_绘制项, 回调函数)
}

// 绘制菜单项事件, 启用该功能需要调用XMenu_EnableDrawItem().
func (w *windowBase) X事件_绘制菜单项1(回调函数 X事件_绘制菜单项1) bool {
	return xc.X窗口_注册事件C1(w.X句柄, xcc.X窗口事件_菜单_绘制项, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_NCDestroy 添加窗口非客户区销毁事件. 在窗口销毁之后触发.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_NCDestroy(fun X事件_非客户区销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_非客户区销毁, onWM_NCDESTROY, fun, allowAddingMultiple...)
}

// onWM_NCDESTROY 窗口非客户区销毁事件.
func onWM_NCDESTROY(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_非客户区销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_非客户区销毁1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}

	EventHandler.RemoveAllCallBack(hWindow)
	return ret
}

// AddEvent_DockPopup 添加框架窗口码头弹出窗格事件. 当用户点击码头上的按钮时, 显示对应的窗格, 当失去焦点时自动隐藏窗格.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_DockPopup(fun X事件_框架窗口码头弹出窗格1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_框架窗口_码头弹出窗格, onXWM_DOCK_POPUP, fun, allowAddingMultiple...)
}

// onXWM_DOCK_POPUP 框架窗口码头弹出窗格事件.
func onXWM_DOCK_POPUP(hWindow int, hWindowDock, hPane int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_框架窗口_码头弹出窗格)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_框架窗口码头弹出窗格1)(hWindow, hWindowDock, hPane, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_WindProc 添加窗口消息过程事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_WindProc(fun X事件_消息过程1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_消息过程, onXWM_WINDPROC, fun, allowAddingMultiple...)
}

// onXWM_WINDPROC 窗口消息过程事件.
func onXWM_WINDPROC(hWindow int, message uint32, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_消息过程)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_消息过程1)(hWindow, message, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_XC_Timer 添加炫彩定时器事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_XC_Timer(fun X事件_炫彩定时器1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_炫彩定时器, onXWM_XC_TIMER, fun, allowAddingMultiple...)
}

// onXWM_XC_TIMER 炫彩定时器事件.
func onXWM_XC_TIMER(hWindow int, nIDEvent uint, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_炫彩定时器)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_炫彩定时器1)(hWindow, nIDEvent, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetFocus_Ele 添加窗口置焦点元素事件. 指定元素获得焦点.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_SetFocus_Ele(fun X事件_设置焦点1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_置焦点, onXWM_SETFOCUS_ELE, fun, allowAddingMultiple...)
}

// onXWM_SETFOCUS_ELE 窗口置焦点元素事件. 指定元素获得焦点.
func onXWM_SETFOCUS_ELE(hWindow int, hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_置焦点)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_设置焦点1)(hWindow, hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Float_Pane 添加浮动窗格事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Float_Pane(fun X事件_浮动窗格1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗格_浮动, onXWM_FLOAT_PANE, fun, allowAddingMultiple...)
}

// onXWM_FLOAT_PANE 浮动窗格事件.
func onXWM_FLOAT_PANE(hWindow int, hFloatWnd int, hPane int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗格_浮动)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_浮动窗格1)(hWindow, hFloatWnd, hPane, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Paint_End 添加窗口绘制完成事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Paint_End(fun X事件_绘制完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_绘制完成, onXWM_PAINT_END, fun, allowAddingMultiple...)
}

// onXWM_PAINT_END 窗口绘制完成事件.
func onXWM_PAINT_END(hWindow int, hDraw int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_绘制完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_绘制完成1)(hWindow, hDraw, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Paint_Display 添加窗口绘制完成并且已经显示到屏幕事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Paint_Display(fun X事件_绘制完成并显示1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_绘制完成并显示, onXWM_PAINT_DISPLAY, fun, allowAddingMultiple...)
}

// onXWM_PAINT_DISPLAY 窗口绘制完成并且已经显示到屏幕事件.
func onXWM_PAINT_DISPLAY(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_绘制完成并显示)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_绘制完成并显示1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_BodyView_Rect 添加框架窗口主视图坐标改变事件. 如果主视图没有绑定元素, 那么当坐标改变时触发此事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_BodyView_Rect(fun X事件_框架窗口主视图坐标改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_框架窗口_主视图坐标改变, onXWM_BODYVIEW_RECT, fun, allowAddingMultiple...)
}

// onXWM_BODYVIEW_RECT 框架窗口主视图坐标改变事件.
func onXWM_BODYVIEW_RECT(hWindow int, width, height int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_框架窗口_主视图坐标改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_框架窗口主视图坐标改变1)(hWindow, width, height, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_FloatWnd_Drag 添加浮动窗口拖动事件. 用户拖动浮动窗口移动, 显示停靠提示.
//   - hArray: HWINDOW array[6], 窗格停靠提示窗口句柄数组, 有6个成员, 分别为:[0]中间十字, [1]左侧, [2]顶部, [3]右侧, [4]底部, [5]停靠位置预览.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_FloatWnd_Drag(fun X事件_浮动窗口拖动1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_浮动窗口拖动, onXWM_FLOATWND_DRAG, fun, allowAddingMultiple...)
}

// onXWM_FLOATWND_DRAG 浮动窗口拖动事件.
func onXWM_FLOATWND_DRAG(hWindow int, hFloatWnd int, hArray *[6]int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_浮动窗口拖动)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_浮动窗口拖动1)(hWindow, hFloatWnd, hArray, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Paint 添加窗口绘制事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Paint(fun X事件_绘制1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_绘制, onWM_PAINT, fun, allowAddingMultiple...)
}

// onWM_PAINT 窗口绘制事件.
func onWM_PAINT(hWindow int, hDraw int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_绘制)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_绘制1)(hWindow, hDraw, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Close 添加窗口关闭事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Close(fun X事件_关闭1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_关闭, onWM_CLOSE, fun, allowAddingMultiple...)
}

// onWM_CLOSE 窗口关闭事件.
func onWM_CLOSE(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_关闭)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_关闭1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Destroy 添加窗口销毁事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Destroy(fun X事件_销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_销毁, onWM_DESTROY, fun, allowAddingMultiple...)
}

// onWM_DESTROY 窗口销毁事件.
func onWM_DESTROY(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_销毁1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseMove 添加窗口鼠标移动事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_MouseMove(fun X事件_鼠标移动1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_移动, onWM_MOUSEMOVE, fun, allowAddingMultiple...)
}

// onWM_MOUSEMOVE 窗口鼠标移动事件.
func onWM_MOUSEMOVE(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_移动)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标移动1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_LButtonDown 添加窗口鼠标左键按下事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_LButtonDown(fun X事件_鼠标左键按下1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_左键按下, onWM_LBUTTONDOWN, fun, allowAddingMultiple...)
}

// onWM_LBUTTONDOWN 窗口鼠标左键按下事件.
func onWM_LBUTTONDOWN(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_左键按下)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标左键按下1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_LButtonUp 添加窗口鼠标左键弹起事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_LButtonUp(fun X事件_鼠标左键弹起1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_左键弹起, onWM_LBUTTONUP, fun, allowAddingMultiple...)
}

// onWM_LBUTTONUP 窗口鼠标左键弹起事件.
func onWM_LBUTTONUP(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_左键弹起)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标左键弹起1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_RButtonDown 添加窗口鼠标右键按下事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_RButtonDown(fun X事件_鼠标右键按下1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_右键按下, onWM_RBUTTONDOWN, fun, allowAddingMultiple...)
}

// onWM_RBUTTONDOWN 窗口鼠标右键按下事件.
func onWM_RBUTTONDOWN(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_右键按下)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标右键按下1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_RButtonUp 添加窗口鼠标右键弹起事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_RButtonUp(fun X事件_鼠标右键弹起1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_右键弹起, onWM_RBUTTONUP, fun, allowAddingMultiple...)
}

// onWM_RBUTTONUP 窗口鼠标右键弹起事件.
func onWM_RBUTTONUP(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_右键弹起)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标右键弹起1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_LButtonDBClick 添加窗口鼠标左键双击事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_LButtonDBClick(fun X事件_鼠标左键双击1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_左键双击, onWM_LBUTTONDBLCLK, fun, allowAddingMultiple...)
}

// onWM_LBUTTONDBLCLK 窗口鼠标左键双击事件.
func onWM_LBUTTONDBLCLK(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_左键双击)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标左键双击1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_RButtonDBClick 添加窗口鼠标右键双击事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_RButtonDBClick(fun X事件_鼠标右键双击1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_右键双击, onWM_RBUTTONDBLCLK, fun, allowAddingMultiple...)
}

// onWM_RBUTTONDBLCLK 窗口鼠标右键双击事件.
func onWM_RBUTTONDBLCLK(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_右键双击)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标右键双击1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseWheel 添加窗口鼠标滚轮滚动事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_MouseWheel(fun X事件_鼠标滚轮滚动1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_滚轮滚动, onWM_MOUSEWHEEL, fun, allowAddingMultiple...)
}

// onWM_MOUSEWHEEL 窗口鼠标滚轮滚动事件.
func onWM_MOUSEWHEEL(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_滚轮滚动)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标滚轮滚动1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ExitSizeMove 添加窗口退出移动或调整大小模式循环事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_ExitSizeMove(fun X事件_退出移动或调整大小模式循环改1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_退出移动或调整大小模式循环改, onWM_EXITSIZEMOVE, fun, allowAddingMultiple...)
}

// onWM_EXITSIZEMOVE 窗口退出移动或调整大小模式循环事件.
func onWM_EXITSIZEMOVE(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_退出移动或调整大小模式循环改)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_退出移动或调整大小模式循环改1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseHover 添加窗口鼠标进入事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_MouseHover(fun X事件_鼠标进入1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_鼠标进入, onWM_MOUSEHOVER, fun, allowAddingMultiple...)
}

// onWM_MOUSEHOVER 窗口鼠标进入事件.
func onWM_MOUSEHOVER(hWindow int, nFlags uint, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_鼠标进入)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标进入1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseLeave 添加窗口鼠标离开事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_MouseLeave(fun X事件_鼠标离开1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_鼠标离开, onWM_MOUSELEAVE, fun, allowAddingMultiple...)
}

// onWM_MOUSELEAVE 窗口鼠标离开事件.
func onWM_MOUSELEAVE(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_鼠标离开)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标离开1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Size 添加窗口大小改变事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Size(fun X事件_大小改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_大小改变, onWM_SIZE, fun, allowAddingMultiple...)
}

// onWM_SIZE 窗口大小改变事件.
func onWM_SIZE(hWindow int, nFlags uint, pPt *xc.X结构_大小, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_大小改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_大小改变1)(hWindow, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Timer 添加窗口定时器事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Timer(fun X事件_定时器1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_定时器, onWM_TIMER, fun, allowAddingMultiple...)
}

// onWM_TIMER 窗口定时器事件.
func onWM_TIMER(hWindow int, nIDEvent uint, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_定时器)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_定时器1)(hWindow, nIDEvent, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetFocus 添加窗口获得焦点事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_SetFocus(fun X事件_获得焦点1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_获得焦点, onWM_SETFOCUS, fun, allowAddingMultiple...)
}

// onWM_SETFOCUS 窗口获得焦点事件.
func onWM_SETFOCUS(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_获得焦点)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_获得焦点1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_KillFocus 添加窗口失去焦点事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_KillFocus(fun X事件_失去焦点1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_窗口_失去焦点, onWM_KILLFOCUS, fun, allowAddingMultiple...)
}

// onWM_KILLFOCUS 窗口失去焦点事件.
func onWM_KILLFOCUS(hWindow int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_窗口_失去焦点)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_失去焦点1)(hWindow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_KeyDown 添加窗口键盘按键事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_KeyDown(fun X事件_键盘按键1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_键盘_按键, onWM_KEYDOWN, fun, allowAddingMultiple...)
}

// onWM_KEYDOWN 窗口键盘按键事件.
func onWM_KEYDOWN(hWindow int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_键盘_按键)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_键盘按键1)(hWindow, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_CaptureChanged 添加窗口鼠标捕获改变事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_CaptureChanged(fun X事件_鼠标捕获改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_捕获改变, onWM_CAPTURECHANGED, fun, allowAddingMultiple...)
}

// onWM_CAPTURECHANGED 窗口鼠标捕获改变事件.
func onWM_CAPTURECHANGED(hWindow int, hWnd uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_捕获改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标捕获改变1)(hWindow, hWnd, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetCursor 添加窗口设置鼠标光标事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_SetCursor(fun X事件_设置鼠标光标1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_鼠标_设置光标, onWM_SETCURSOR, fun, allowAddingMultiple...)
}

// onWM_SETCURSOR 窗口设置鼠标光标事件.
func onWM_SETCURSOR(hWindow int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_鼠标_设置光标)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_设置鼠标光标1)(hWindow, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Char 添加窗口字符事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_Char(fun X事件_字符消息1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_字符, onWM_CHAR, fun, allowAddingMultiple...)
}

// onWM_CHAR 窗口字符事件.
func onWM_CHAR(hWindow int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_字符)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_字符消息1)(hWindow, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_DropFiles 添加拖动文件到窗口事件.
//
// fun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *windowBase) AddEvent_DropFiles(fun X事件_拖动文件到窗口1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X窗口事件_拖动文件到窗口, onWM_DROPFILES, fun, allowAddingMultiple...)
}

// onWM_DROPFILES 拖动文件到窗口事件.
func onWM_DROPFILES(hWindow int, hDropInfo uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hWindow, xcc.X窗口事件_拖动文件到窗口)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_拖动文件到窗口1)(hWindow, hDropInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
